
// 云函数入口文件
const cloud = require('wx-server-sdk')

cloud.init({
  env: cloud.DYNAMIC_CURRENT_ENV
})

const db = cloud.database()
const _ = db.command
const todosCollection = db.collection('todos')

// 云函数入口函数
exports.main = async (event, context) => {
  const wxContext = cloud.getWXContext()
  const { type, data } = event

  // 确保用户已登录
  if (!wxContext.OPENID) {
    return {
      code: -1,
      msg: '用户未登录'
    }
  }

  switch (type) {
    case 'create':
      return await createTodo(wxContext.OPENID, data)
    case 'update':
      return await updateTodo(wxContext.OPENID, data)
    case 'delete':
      return await deleteTodo(wxContext.OPENID, data)
    case 'list':
      return await listTodos(wxContext.OPENID, data)
    case 'toggleStatus':
      return await toggleTodoStatus(wxContext.OPENID, data)
    case 'getTodoById':
      return await getTodoById(wxContext.OPENID, data)
    default:
      return {
        code: -1,
        msg: '未知的操作类型'
      }
  }
}

// 创建待办事项
async function createTodo(openid, todoData) {
  try {
    // 确保reminderTime是正确的本地时间
    let reminderTime;
    if (todoData.reminderTime) {
      const date = new Date(todoData.reminderTime);
      // 转换为本地时间
      reminderTime = new Date(date);
      console.log('创建待办事项 - 原始时间:', todoData.reminderTime);
      console.log('创建待办事项 - 转换后时间:', reminderTime);
    }
    
    const data = {
      ...todoData,
      reminderTime: reminderTime,
      userId: openid,
      createTime: db.serverDate(),
      updateTime: db.serverDate(),
      status: false
    }

    const result = await todosCollection.add({
      data
    })

    return {
      code: 0,
      msg: '创建成功',
      data: {
        _id: result._id,
        ...data
      }
    }
  } catch (err) {
    console.error('[创建待办事项]失败：', err)
    return {
      code: -1,
      msg: '创建待办事项失败',
      error: err
    }
  }
}

// 更新待办事项
async function updateTodo(openid, { _id, ...updateData }) {
  try {
    // 确保只能更新自己的待办事项
    const todo = await todosCollection.doc(_id).get()
    if (!todo.data || todo.data.userId !== openid) {
      return {
        code: -1,
        msg: '无权限更新此待办事项'
      }
    }

    // 准备更新数据
    const data = { updateTime: db.serverDate() }
    
    // 只更新提供的字段
    if (updateData.title !== undefined) data.title = updateData.title
    if (updateData.content !== undefined) data.content = updateData.content
    if (updateData.tags !== undefined) data.tags = updateData.tags
    if (updateData.status !== undefined) data.status = updateData.status
    
    // 确保reminderTime是Date类型
    if (updateData.reminderTime !== undefined) {
      data.reminderTime = new Date(updateData.reminderTime)
    }

    console.log('更新待办事项数据:', data)

    await todosCollection.doc(_id).update({
      data
    })

    // 获取更新后的完整数据
    const updatedTodo = await todosCollection.doc(_id).get()

    return {
      code: 0,
      msg: '更新成功',
      data: updatedTodo.data
    }
  } catch (err) {
    console.error('[更新待办事项]失败：', err)
    return {
      code: -1,
      msg: '更新待办事项失败',
      error: err
    }
  }
}

// 删除待办事项
async function deleteTodo(openid, { _id }) {
  try {
    // 确保只能删除自己的待办事项
    const todo = await todosCollection.doc(_id).get()
    if (!todo.data || todo.data.userId !== openid) {
      return {
        code: -1,
        msg: '无权限删除此待办事项'
      }
    }

    await todosCollection.doc(_id).remove()

    return {
      code: 0,
      msg: '删除成功'
    }
  } catch (err) {
    console.error('[删除待办事项]失败：', err)
    return {
      code: -1,
      msg: '删除待办事项失败',
      error: err
    }
  }
}

// 查询待办事项列表
async function listTodos(openid, { date, status, startTime, endTime } = {}) {
  try {
    let query = todosCollection.where({
      userId: openid
    })

    // 按日期筛选
    if (date) {
      // 确保date是有效的日期字符串
      const dateStr = new Date(date).toISOString().split('T')[0]
      const startDate = new Date(`${dateStr}T00:00:00.000Z`)
      const endDate = new Date(`${dateStr}T23:59:59.999Z`)

      console.log('日期筛选范围:', startDate, '至', endDate)

      query = query.where({
        reminderTime: _.gte(startDate).and(_.lte(endDate))
      })
    }
    // 按时间范围筛选
    else if (startTime && endTime) {
      const startDate = new Date(startTime)
      const endDate = new Date(endTime)

      console.log('时间范围筛选:', startDate, '至', endDate)

      query = query.where({
        reminderTime: _.gte(startDate).and(_.lte(endDate))
      })
    }

    // 按状态筛选
    if (status !== undefined) {
      query = query.where({
        status: status
      })
    }

    // 按提醒时间排序
    const todos = await query.orderBy('reminderTime', 'asc').get()

    return {
      code: 0,
      msg: '查询成功',
      data: todos.data
    }
  } catch (err) {
    console.error('[查询待办事项列表]失败：', err)
    return {
      code: -1,
      msg: '查询待办事项列表失败',
      error: err
    }
  }
}

// 更新待办事项状态
async function toggleTodoStatus(openid, { _id }) {
  try {
    // 确保只能更新自己的待办事项
    const todo = await todosCollection.doc(_id).get()
    if (!todo.data || todo.data.userId !== openid) {
      return {
        code: -1,
        msg: '无权限更新此待办事项'
      }
    }

    const newStatus = !todo.data.status
    await todosCollection.doc(_id).update({
      data: {
        status: newStatus,
        updateTime: db.serverDate()
      }
    })

    return {
      code: 0,
      msg: '状态更新成功',
      data: {
        status: newStatus
      }
    }
  } catch (err) {
    console.error('[更新待办事项状态]失败：', err)
    return {
      code: -1,
      msg: '更新待办事项状态失败',
      error: err
    }
  }
}

// 根据ID获取待办事项
async function getTodoById(openid, { _id }) {
  try {
    // 获取待办事项
    const todo = await todosCollection.doc(_id).get()
    
    // 确保只能获取自己的待办事项
    if (!todo.data || todo.data.userId !== openid) {
      return {
        code: -1,
        msg: '无权限查看此待办事项'
      }
    }

    return {
      code: 0,
      msg: '获取成功',
      data: todo.data
    }
  } catch (err) {
    console.error('[获取待办事项]失败：', err)
    return {
      code: -1,
      msg: '获取待办事项失败',
      error: err
    }
  }
}